package com.yidu.hbats.action.NutritionAtsScheme;

import com.yidu.hbats.action.vo.NutritionAtsSchemeVo;
import com.yidu.hbats.model.*;
import com.yidu.hbats.service.NutritionAtsScheme.NutritionAtsSchemeAthleteService;
import com.yidu.hbats.service.NutritionAtsScheme.NutritionAtsSchemeAuditService;
import com.yidu.hbats.service.NutritionAtsScheme.NutritionAtsSchemeExpertService;
import com.yidu.hbats.service.NutritionAtsScheme.NutritionAtsSchemeService;
import com.yidu.hbats.service.emp.AtsEmpAthleteService;
import com.yidu.hbats.service.emp.AtsEmpExpertService;
import com.yidu.springbootdemo.permission.domain.Tuser;
import com.yidu.utils.FileTools;
import com.yidu.utils.Message;
import com.yidu.utils.RedisUtil;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

@Controller
@RequestMapping("NutritionAtsSchemeController")
public class NutritionAtsSchemeController {

    //方案信息接口
    @Resource
    public NutritionAtsSchemeService nutritionAtsSchemeService;

    //运动员接口
    @Resource
    public AtsEmpAthleteService atsEmpAthleteService;

    //方案对应的运动员表接口
    @Resource
    public NutritionAtsSchemeAthleteService nutritionAtsSchemeAthleteService;

    //专家信息接口
    @Resource
    public AtsEmpExpertService atsEmpExpertService;

    @Resource
    //专家咨询接口
    public NutritionAtsSchemeExpertService nutritionAtsSchemeExpertService;

    @Resource
    //审核表接口
    public NutritionAtsSchemeAuditService nutritionAtsSchemeAuditService;


    //文件上传管理工具
    @Resource
    FileTools fileTools;

    //二级缓存
    @Resource
    RedisUtil redisUtil;

    /**
     * 运动营养方案的查询所有
     * @param atsScheme 方案表类
     * @param pageNum  页
     * @param pageSize 行
     * @param request request对象
     * @return  返回一个map对象
     */
    @ResponseBody
    @RequestMapping("selectAll1")
    public Map<String,Object> selectAll1(AtsScheme atsScheme, @RequestParam("page") Integer pageNum,
                                        @RequestParam("limit") Integer pageSize, HttpServletRequest request){
        //new一个map集合
        Map<String,Object> map=new HashMap<>();
        //用session把登录Tuser模型弄出来
        Tuser user = (Tuser) request.getSession().getAttribute("user");
        //new一个List集合AtsScheme
        List<AtsScheme> list=new ArrayList<>();
        //定义一个int为0
        int count=0;
        //判断用户表的外键关联为空，那就是超级管理员之类的，就可以查看所有
        //为1的是领导 为2的是教练员  为3的是专家 为4的是运动员
        //判断为2就是教练员
        if(user.getCompanyNum()=="2"||"2".equals(user.getCompanyNum())){
            //方案对象传入教练员的外键
            atsScheme.setCoachId(Integer.valueOf(user.getFilId()));
            //调用查询所有one的方法
            list=nutritionAtsSchemeService.selectAll1(atsScheme,pageNum,pageSize);
            //调用查询所有one的总行数方法
            count=nutritionAtsSchemeService.selectCountone(atsScheme);
            //判断数字为4的就是运动员
        }else if(user.getCompanyNum()=="4"||"4".equals(user.getCompanyNum())){
            //用方案表备注字段传入运动员的外键查询
            atsScheme.setRemark(user.getFilId());
            //调用查询运动员的所有方案one
            list=nutritionAtsSchemeService.selectAthleteAllOnewx(atsScheme,pageNum,pageSize);
            //调用查询运动员的所有方案的总行数one
            count=nutritionAtsSchemeService.selectAthleteAllCountOnewx(atsScheme);
            //判断session里的用户名字为admin 代表超级管理员
        }else if(user.getUserName().equals("admin")){
            //管理员查看所有
            //调用查询所有one的方法selectAll1
            list=nutritionAtsSchemeService.selectAll1(atsScheme,pageNum,pageSize);
            //调用查询所有的总行数one的方法selectCountone
            count=nutritionAtsSchemeService.selectCountone(atsScheme);
            //判断为1的进来是领导
        }else if(user.getCompanyNum()=="1"||"1".equals(user.getCompanyNum())){
            //领导查看 10 20 21状态的
            //调用audit领导的查看所有方法selectAuditAllOne
            list=nutritionAtsSchemeService.selectAuditAllOne(atsScheme,pageNum,pageSize);
            //调用audit领导的查看所有的总行数方法selectCountone
            count=nutritionAtsSchemeService.selectCountone(atsScheme);
            //判断为3的进来是专家
        }else if(user.getCompanyNum()=="3"||"3".equals(user.getCompanyNum())){
            //专家查看
            //传入备注字段做专家外键
            atsScheme.setRemark(user.getFilId());
            //调用expert专家查询方法selectAuditAllOne
            list=nutritionAtsSchemeService.selectAuditAllOne(atsScheme,pageNum,pageSize);
            //调用expert专家查询方法的总行数方法selectCountone
            count=nutritionAtsSchemeService.selectCountone(atsScheme);
        }
        //写layui前台要的json数据类型
        map.put("code", 0);
        map.put("msg", "");
        map.put("count", count);
        map.put("data", list);
        return map;
    }


    /**
     * 增加或者修改方法
     * @param nutritionAtsSchemeVo 方案的vo层 TrainingPlan心理方案文件夹
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("addOrupdate")
    public Message addOrupdate(NutritionAtsSchemeVo nutritionAtsSchemeVo){
        //判断vo里面的文件one不等于空
        if(nutritionAtsSchemeVo.getFileone().getOriginalFilename()!=null &&!"".equals(nutritionAtsSchemeVo.getFileone().getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file1=fileTools.saveFile("nutrition",nutritionAtsSchemeVo.getFileone());
                //传入vo的文件地址
                nutritionAtsSchemeVo.setFile1(file1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //判断vo里面的文件two不等于空
        if(nutritionAtsSchemeVo.getFiletwo().getOriginalFilename()!=null &&!"".equals(nutritionAtsSchemeVo.getFiletwo().getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file2 = fileTools.saveFile("nutrition",nutritionAtsSchemeVo.getFiletwo());
                //传入vo的文件地址
                nutritionAtsSchemeVo.setFile2(file2);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //判断vo里面的文件three不等于空
        if(nutritionAtsSchemeVo.getFilethree().getOriginalFilename()!=null &&!"".equals(nutritionAtsSchemeVo.getFilethree().getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file3=fileTools.saveFile("nutrition",nutritionAtsSchemeVo.getFilethree());
                //传入vo的文件地址
                nutritionAtsSchemeVo.setFile3(file3);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        //id不为空是修改
        if(nutritionAtsSchemeVo.getSchemeId()!=null &&!"".equals(nutritionAtsSchemeVo.getSchemeId())){
            //调用生成的修改方法
            nutritionAtsSchemeService.updateByPrimaryKeySelective(nutritionAtsSchemeVo);
        }else{//否则就是增加
            //调用  生成的增加有选择的方法
            nutritionAtsSchemeService.insertSelective(nutritionAtsSchemeVo);
        }
        //new出提示对象传入1
        Message message=new Message();
        message.setNum(1);
        message.setMsg("成功");
        return message;
    }

    /**
     * 查询当前教练员的所有运动员
     * @param coachId 教练员的运动员id
     * @return
     */
    @ResponseBody
    @RequestMapping("checkboxselectAll")
    public List<AtsEmpAthlete> checkboxselectAll(int coachId){
        //调用教练员表的根据id查询方法selectByCoachIdone
        List<AtsEmpAthlete> list=atsEmpAthleteService.selectByCoachIdone(coachId);
        //返回一个list集合
        return list;
    }

    /**
     * 根据主键id查询所有
     * @param schemeId 方案主键id
     * @return
     */
    @ResponseBody
    @RequestMapping("findAll")
    public AtsScheme findAll(int schemeId){
        //调用方案表根据id查询的方法findByIdOne
        AtsScheme atsScheme=nutritionAtsSchemeService.findByIdOne(schemeId);
        //返回方案表
        return atsScheme;
    }

    /**
     * 根据方案id查运动员
     * @param schemeId 方案主键id
     * @return
     */
    @ResponseBody
    @RequestMapping("findByIdone")
    public List<AtsSchemeAthlete> findByIdone(int schemeId){
        //调用方案对应的运动员表查询运动员
        List<AtsSchemeAthlete> list=nutritionAtsSchemeAthleteService.selectByIdone(schemeId);
        //返回一个list集合
        return list;
    }
    /**
     * 逻辑删除
     * @param schemeId 方案主键
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("updateIsva")
    public Message updateIsva(int schemeId){
        //new出提示类
        Message message = new Message();
        //判断方案id不为空
        if(!StringUtils.isEmpty(schemeId)){
            //则调用修改方法
            int rows=nutritionAtsSchemeService.updateByPrimaryKeySelectiveone(schemeId);
            //判断大于0
            if(rows>0){
                //传入1和提示
                message.setNum(1);
                message.setMsg("删除成功!");
            }else{//判断小于0
                //传入1和提示
                message.setNum(1);
                message.setMsg("操作失败!");
            }
        }
        //返回提示类
        return message;
    }

    /**
     * 批量删除
     * @param schemeId 方案主键id
     * @return
     */
    @ResponseBody
    @RequestMapping("deleteAllone")
    public Message deleteAllone(String schemeId){
        //new出提示类
        Message message=new Message();
        //用spring里面的判断方案id不为空schemeId
        if(!StringUtils.isEmpty(schemeId)){
            //定义一个数组arr然后分割split传过来的字符串id
            String[] arr=schemeId.split(",");
            //定义一个int为0 变量为one
            int one=0;
            //循环数组长度arr.length
            for (int i = 0; i < arr.length; i++) {
                //int的变量++
                one++;
                //int调用方案的修改方法Selectiveone
                int rows=nutritionAtsSchemeService.updateByPrimaryKeySelectiveone(Integer.valueOf(arr[i]));
                //判断大于0
                //选择行数大于0删除成功
                if(rows>0){
                    //提示类传入删除几行和1
                    message.setNum(1);
                    message.setMsg("删除成功!删除了"+one+"行!");
                }else{//否则删除失败
                    message.setNum(1);
                    message.setMsg("操作失败!");
                }
            }
        }
        //返回提示类
        return message;
    }

    /**
     * 查询所有有效的专家
     * @return
     */
    @ResponseBody
    @RequestMapping("findAlltwo")
    public List<AtsEmpExpert> findAlltwo(){
        //调用专家表的查询所有有效的专家findAllFour
        List<AtsEmpExpert> list=atsEmpExpertService.findAllFour();
        //返回一个list集合
        return list;
    }

    /**
     * 方案表
     * 根据id查询所有
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("selectByPrimaryKeyOne")
    public AtsScheme selectByPrimaryKeyOne(int schemeId){
        //调用方案表的查询所有的方法selectByPrimaryKey
        AtsScheme atsScheme=nutritionAtsSchemeService.selectByPrimaryKey(schemeId);
        //返回方案表
        return atsScheme;
    }

    /**
     *
     * 新增
     * @param atsSchemeAudit 审核表
     * @param expertId 专家id
     * @param applyForExp 申请专家理由
     * @return
     */
    @ResponseBody
    @RequestMapping("expertone")
    public Message expertone(AtsSchemeAudit atsSchemeAudit,int expertId,String applyForExp){
        //调用专家咨询表里的查询所有的方法selectByPrimaryKey
        AtsEmpExpert atsScheme=atsEmpExpertService.selectByPrimaryKey(expertId);
        //int调用审核表的新增方法insertSelective
        int rows=nutritionAtsSchemeAuditService.insertSelective(atsSchemeAudit);
        //new出一个提示类
        Message message=new Message();
        //判断rows大于0
        if(rows>0){
            //new出专家咨询表模型
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            //传入专家名字ExpertName
            atsSchemeExpert.setExpertName(atsScheme.getExpertName());
            //传入专家id
            atsSchemeExpert.setExpertId(atsScheme.getExpertId().toString());
            //传入方案主键
            atsSchemeExpert.setSchemeId(Integer.valueOf(atsSchemeAudit.getSaId()));
            //传入方案名字
            atsSchemeExpert.setSaName(atsSchemeAudit.getSaName());
            //传入申请专家理由
            atsSchemeExpert.setApplyForExp(applyForExp);
            //获取当前的日期
            Date date = new Date();
            //设置日期格式
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //获取String类型的时间
            String str = df.format(date);
            //获取日期util.Date
            Date utilDate = new Date();
            //newy出java.sql.Date sqlDate
            java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
            //传入创建时间
            atsSchemeExpert.setCreatTime(sqlDate);
            //默认传入10为咨询状态
            atsSchemeExpert.setAuditState("10");
            //传入创建人
            atsSchemeExpert.setCreater(atsSchemeAudit.getCreater());
            //默认传入1为有效
            atsSchemeExpert.setIsva(1);
            //传入申请咨询时间
            atsSchemeExpert.setApplyForTime(str);
            //调用专家咨询的新增专家咨询
            nutritionAtsSchemeExpertService.insertSelective(atsSchemeExpert);
        }
        message.setNum(1);
        message.setMsg("操作成功!");
        //返回提示类
        return message;
    }

    /**
     * 查询是否已经提交审核和专家申请
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("selectState")
    public Message selectState(int schemeId){
        //new一个提示类
        Message message=new Message();
        //int调用专家咨询的查询是否已经提交审核和专家申请selectByOne
        int rows=nutritionAtsSchemeExpertService.selectByOne(schemeId);
        //判断rows大于0
        if(rows>0){
            message.setNum(1);
            message.setMsg("审核和申请已经提交过，是否修改");
        }else{
            message.setNum(0);
        }
        //返回提示类
        return message;
    }

    /**
     * 根据方案id查询专家咨询表
     * @param schemeId 方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectBySix")
    public AtsSchemeExpert selectBySix(Integer schemeId){
        //调用专家咨询表的查询方法selectBySix
        AtsSchemeExpert atsSchemeExpert=nutritionAtsSchemeExpertService.selectBySix(schemeId);
        //返回专家咨询表
        return atsSchemeExpert;
    }

    /**
     * 修改申请和咨询
     * @param applyForExp 申请理由
     * @param expertId  主键id
     * @param saName  方案名称
     * @param saId  方案外键
     * @return 返回一个提示工具类
     */
    @ResponseBody
    @RequestMapping("updateState")
    public Message updateState(String applyForExp,int expertId,String saName,int saId){
        //根据传过来的专家主键查询
        AtsEmpExpert atsScheme=atsEmpExpertService.selectByPrimaryKey(expertId);
        //new一个提示类
        Message message=new Message();
        //用spring里面的判断方案id不为空
        if(!StringUtils.isEmpty(expertId)){
            //new出审核表模型
            AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
            //传入方案名称参数
            atsSchemeAudit.setSaName(saName);
            //传入方案id参数，要根据id修改
            atsSchemeAudit.setSaId(Integer.valueOf(saId).toString());
            //util.Date
            Date utilDate = new Date();
            //new出java.sql.Date sqlDate
            java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
            //传入创建时间
            atsSchemeAudit.setCreatTime(sqlDate);
            //调用审核的修改查询方法updateByPrimaryKeySelectivetwo
            nutritionAtsSchemeAuditService.updateByPrimaryKeySelectivetwo(atsSchemeAudit);
            //new出专家咨询表模型
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            //util.Date
            Date utilDateone = new Date();
            //mew出java.sql.Date sqlDateon
            java.sql.Date sqlDateone = new java.sql.Date(utilDateone.getTime());
            //传入创建时间
            atsSchemeExpert.setCreatTime(sqlDateone);
            //传入方案名称
            atsSchemeExpert.setSaName(saName);
            //传入申请理由
            atsSchemeExpert.setApplyForExp(applyForExp);
            //获取当前的日期Date
            Date date = new Date();
            //设置日期格式 SimpleDateFormat
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //获取String类型的时间
            String str = df.format(date);
            //传入申请时间
            atsSchemeExpert.setApplyForTime(str);
            //传入方案外键根据它来修改
            atsSchemeExpert.setSchemeId(saId);
            //传入专家外键
            atsSchemeExpert.setExpertId(atsScheme.getExpertId().toString());
            //传入专家名字
            atsSchemeExpert.setExpertName(atsScheme.getExpertName());
            //调用审核的修改查询方法updateByPrimaryKeySelectiveone
            nutritionAtsSchemeExpertService.updateByPrimaryKeySelectiveone(atsSchemeExpert);
            message.setNum(1);
            message.setMsg("提交成功!");
        }//返回提示类
        return message;
    }

    /**
     * 查询所有带分页
     * @param atsSchemeAudit 审核表
     * @param pageNum
     * @param pageSize
     * @return
     */
    @ResponseBody
    @RequestMapping("selectStateAll")
    public Map<String,Object> selectStateAll(AtsSchemeAudit atsSchemeAudit,
               @RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize){
        //System.out.println(pageNum+"    "+pageSize);
        //new出一个map集合
        Map<String,Object> map=new HashMap<>();
        //List调用审核的查询所有的方法selectByPrimaryKeyTwowx
        List<AtsSchemeAudit> list=nutritionAtsSchemeAuditService.selectByPrimaryKeyTwowx(atsSchemeAudit,pageNum,pageSize);
        map.put("code", 0);
        map.put("msg", "");
        //调用审核的查询所有行数的方法selectByPrimaryKeyCountTwowx
        map.put("count", nutritionAtsSchemeAuditService.selectByPrimaryKeyCountTwowx(atsSchemeAudit));
        map.put("data", list);
        return map;
    }

    /**
     * 审核表的修改
     * @param atsSchemeAudit
     * @param yesOrno
     * @return
     */
    @ResponseBody
    @RequestMapping("auditUpdate")
    public Message auditUpdate(AtsSchemeAudit atsSchemeAudit,int yesOrno){
        //传入审核状态
        atsSchemeAudit.setAuditState(String.valueOf(yesOrno));
        //获取当前的日期
        Date date = new Date();
        //设置日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //获取String类型的时间
        String str = df.format(date);
        //传入审核时间
        atsSchemeAudit.setAuTime(str);
        //new一个提示类
        Message message=new Message();
        //调用审核的修改方法updateByPrimaryKeySelectivethree
        int rows=nutritionAtsSchemeAuditService.updateByPrimaryKeySelectivethree(atsSchemeAudit);
        //判断rows大于0
        if(rows>0){
            //得到专家表的模型
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            //传入方案主键
            atsSchemeExpert.setSchemeId(Integer.valueOf(atsSchemeAudit.getSaId()));
            //传入审核状态
            atsSchemeExpert.setAuditState(String.valueOf(yesOrno));
            //调用审核的修改方法updateByPrimaryKeySelectiveThree
            nutritionAtsSchemeExpertService.updateByPrimaryKeySelectiveThree(atsSchemeExpert);
            message.setMsg("操作成功!");
            message.setNum(1);
        }
        //返回提示类
        return message;
    }

    /**
     *查询审核表
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("selectAudit")
    public AtsSchemeAudit selectAudit(int schemeId){
        //调用审核表的查询的方法selectBySchemeIdFour
        AtsSchemeAudit atsSchemeAudit=nutritionAtsSchemeAuditService.selectBySchemeIdFour(schemeId);
        //返回审核表
        return atsSchemeAudit;
    }

    /**
     * 查询审核表的总行数
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("selectAuditcount")
    public Message selectAuditcount(int schemeId){
        //new出一个提示类
        Message message=new Message();
        //调用审核表的总行数方法selectByPrimaryKeyCountThree
        int rows=nutritionAtsSchemeAuditService.selectByPrimaryKeyCountThree(schemeId);
        //判断rows大于0
        if(rows>0){
            message.setNum(1);
        }else{
            message.setNum(0);
        }
        //返回提示类
        return message;
    }

    /**
     *  查询专家咨询表
     * @param session
     * @param
     * @param pageNum
     * @param pageSize
     * @return
     */
    @ResponseBody
    @RequestMapping("selectExperttwo")
    public Map<String,Object> selectExpert(HttpSession session, AtsSchemeExpert atsSchemeExpert,
                                           @RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize){
        //new出一个map集合
        Map<String,Object> map=new HashMap<>();
        //取出session的Tuser模型
        Tuser user = (Tuser) session.getAttribute("user");
        //得到咨询表的id
        atsSchemeExpert.setExpertId(user.getFilId());
        //List调用专家咨询查询所有的方法findAllSIxwx
        List<AtsSchemeExpert> list=nutritionAtsSchemeExpertService.findAllSIxwx(atsSchemeExpert,pageNum,pageSize);
        map.put("code", 0);
        map.put("msg", "");
        //调用专家咨询的总行数countSIxwx
        map.put("count", nutritionAtsSchemeExpertService.countSIxwx(atsSchemeExpert));
        map.put("data", list);
        //返回map集合
        return map;
    }

    /**
     * 查询专家回复
     * @param seId
     * @return
     */
    @ResponseBody
    @RequestMapping("selectExpertState")
    public AtsSchemeExpert selectExpertState(int seId){
        //调用专家咨询的查询专家回复方法selectByPrimaryKeyFour
        AtsSchemeExpert atsSchemeExpert=nutritionAtsSchemeExpertService.selectByPrimaryKeyFour(seId);
        //返回专家咨询表
        return atsSchemeExpert;
    }

    /**
     * 专家已知回复
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("updateExpertState")
    public  Message updateExpertState(int schemeId){
        //new一个提示类
        Message message=new Message();
        //得到专家咨询表的模型
        AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
        //得到专家咨询表的SchemeId
        atsSchemeExpert.setSchemeId(schemeId);
        //得到专家咨询的状态30
        atsSchemeExpert.setAuditState("30");
        //调用专家咨询的专家回复updateByPrimaryKeySelectiveThree
        int rows=nutritionAtsSchemeExpertService.updateByPrimaryKeySelectiveThree(atsSchemeExpert);
        //判断rows大于0
        if(rows>0){
            //得到审核表的模型
            AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
            //得到审核表的SaId
            atsSchemeAudit.setSaId(String.valueOf(schemeId));
            //得到审核表的状态30
            atsSchemeAudit.setAuditState("30");
            //调用审核标的专家回复updateByPrimaryKeySelectiveFour
            nutritionAtsSchemeAuditService.updateByPrimaryKeySelectiveFour(atsSchemeAudit);
            message.setNum(1);
            message.setMsg("已成专家已获知待回复!");
        }
        //返回提示类
        return message;
    }

    /**
     * 专家咨询表
     * 专家进行回复
     * @param schemeId 方案表的id
     * @param results 回复
     * @return
     */
    @ResponseBody
    @RequestMapping("updateResules")
    public Message updateResules(int schemeId,String results){
        //new一个提示类
        Message message=new Message();
        //得到专家咨询表的模型
        AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
        //得到专家咨询表的idSchemeId
        atsSchemeExpert.setSchemeId(schemeId);
        //得到专家咨询表的回复setResults
        atsSchemeExpert.setResults(results);
        //得到专家咨询表的状态40
        atsSchemeExpert.setAuditState("40");
        //int得到专家回复的方法updateByPrimaryKeySelective
        int rows=nutritionAtsSchemeExpertService.updateByPrimaryKeySelective(atsSchemeExpert);
        //判断rows大于0
        if(rows>0){
            //得到审核表的模型
            AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
            //得到审核表的SaId
            atsSchemeAudit.setSaId(String.valueOf(schemeId));
            //得到审核表的状态40
            atsSchemeAudit.setAuditState("40");
            //调用审核的专家回复updateByPrimaryKeySelectiveFour
            nutritionAtsSchemeAuditService.updateByPrimaryKeySelectiveFour(atsSchemeAudit);
            message.setMsg("您的反馈消息已提交!");
            message.setNum(1);
        }
        //返回提示类
        return message;
    }

    /**
     * 方案表的反馈实施
     * @param resultEffect
     * @param resultExp
     * @param schemeId
     * @param fileone
     * @return
     */
    @ResponseBody
    @RequestMapping("addScheme")
    public Message addScheme(String resultEffect,String resultExp,int schemeId
            ,@RequestParam(value = "fileone", required = false) MultipartFile fileone){
        //new出一个提示类
        Message message=new Message();
        //得到方案表的模型
        AtsScheme atsScheme=new AtsScheme();
        //判断文件是否为空
        if(fileone.getOriginalFilename()!=null &&!"".equals(fileone.getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file1=fileTools.saveFile("TrainingPlan",fileone);
                //文件地址
                atsScheme.setResultFile(file1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //获取当前的日期
        Date date = new Date();
        //设置日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //获取String类型的时间
        String str = df.format(date);
        //得到方案表的时间
        atsScheme.setResultTime(str);
        //得到方案表的SchemeId(s
        atsScheme.setSchemeId(schemeId);
        //得到方案表的实施效果ResultEffect
        atsScheme.setResultEffect(resultEffect);
        //得到方案表的实施情况ResultExp
        atsScheme.setResultExp(resultExp);
        //调用方案的反馈方法updateByPrimaryKeySelective
        int rows=nutritionAtsSchemeService.updateByPrimaryKeySelective(atsScheme);
        if(rows>0){
            message.setNum(1);
            message.setMsg("反馈成功!");
        }
        //返回提示类
        return message;
    }

    /**
     *  查询反馈的信息
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("findResults")
    public AtsScheme findResults(int schemeId){
        //调用方案表的查询反馈信息findByIdOne
        AtsScheme atsScheme=nutritionAtsSchemeService.findByIdOne(schemeId);
        //返回方案表
        return atsScheme;
    }

    /**
     *
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("findstateOne")
    public AtsSchemeExpert findstateOne(int schemeId){
        //调用咨询表的查询方法selectByPrimaryKeyFive
        AtsSchemeExpert atsSchemeExpert=nutritionAtsSchemeExpertService.selectByPrimaryKeyFive(schemeId);
        return atsSchemeExpert;
    }

    /**
     * 中心领导不同意后，继续上传方案
     * @param schemeId 方案主键
     * @param applyForExp 申请理由
     * @param expertId 专家id
     * @param saName 方案名称
     * @return
     */
    @ResponseBody
    @RequestMapping("updateStateTwo")
    public Message updateState(Integer schemeId,String applyForExp,Integer expertId,String saName) {
        //根据传过来的专家主键查询
        AtsEmpExpert atsScheme = atsEmpExpertService.selectByPrimaryKey(expertId);
        //new出提示类对象
        Message message = new Message();
        //得到审核表的模型
        AtsSchemeAudit atsSchemeAudit = new AtsSchemeAudit();
        //得到审核表的状态10
        atsSchemeAudit.setAuditState("10");
        //得到审核表的SaId
        atsSchemeAudit.setSaId(String.valueOf(schemeId));
        //得到审核的修改方法updateByPrimaryKeySelectivethree
        int rows = nutritionAtsSchemeAuditService.updateByPrimaryKeySelectivethree(atsSchemeAudit);
        //rows大于0
        if (rows > 0) {
            //得到咨询表的模型atsSchemeExpert
            AtsSchemeExpert atsSchemeExpert = new AtsSchemeExpert();
            //传入查出来专家名字
            atsSchemeExpert.setExpertName(atsScheme.getExpertName());
            //传入传过来的专家Id
            atsSchemeExpert.setExpertId(String.valueOf(expertId));
            //传入方案Id
            atsSchemeExpert.setSchemeId(schemeId);
            //传入状态为10
            atsSchemeExpert.setAuditState("10");
            //util.Date
            Date utilDateone = new Date();
            //new出java.sql.Date sqlDateone
            java.sql.Date sqlDateone = new java.sql.Date(utilDateone.getTime());
            //传入创建时间
            atsSchemeExpert.setCreatTime(sqlDateone);
            //传入方案名称
            atsSchemeExpert.setSaName(saName);
            //传入申请理由
            atsSchemeExpert.setApplyForExp(applyForExp);
            //传入申请时间
            Date date = new Date();//获取当前的日期
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            String str = df.format(date);//获取String类型的时间
            atsSchemeExpert.setApplyForTime(str);
            //执行修改专家咨询表的方法
            nutritionAtsSchemeExpertService.updateByPrimaryKeySelectiveone(atsSchemeExpert);
            message.setNum(1);
            message.setMsg("操作成功!");
        }
        //返回提示类
        return message;
    }
    /**
     * 根据教练员外键 修改是否查看
     * @param session
     * @param atsSchemeAthlete  运动员关联表对象
     * @return
     */
    @ResponseBody
    @RequestMapping("addExp")
    public Message message(HttpSession session,AtsSchemeAthlete atsSchemeAthlete){
        //new出提示类对象
        Message message=new Message();
        //取出session的Tuser模型
        Tuser user = (Tuser) session.getAttribute("user");
        //判断4为运动员进来
        if("4".equals(user.getCompanyNum())){
            //传入session对象的外键
            atsSchemeAthlete.setAthleteId(Integer.valueOf(user.getFilId()));
            //调用带0zero的修改方法
            int rows=nutritionAtsSchemeAthleteService.updateByPrimaryKeySelectiveZero(atsSchemeAthlete);
            //判断大于0
            if(rows>0){
                //传入1
                message.setNum(1);
                message.setMsg("操作成功！");
            }
            //返回提示类
            return message;
        }
        //返回null
        return null;
    }

    /**
     * 根据方案id查询运动员
     * @param schemeId  方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectAthleteById")
    public List<AtsSchemeAthlete> selectAthleteById(Integer schemeId){
        //调用方案对应的运动员的查询方法selectByIdone
        List<AtsSchemeAthlete> atsSchemeAthlete=nutritionAtsSchemeAthleteService.selectByIdone(schemeId);
        //返回方案对应的运动员表
        return atsSchemeAthlete;
    }

    /**
     * 根据方案id 查询审核状态
     * @param saId 方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectBySaId")
    public AtsSchemeAudit selectBySaId(Integer saId){
        //调用方案的运动员的查询审核状态selectBySchemeIdFour
        AtsSchemeAudit atsSchemeAthlete=nutritionAtsSchemeAuditService.selectBySchemeIdFour(saId);
        //返回方案对应的运动员表
        return atsSchemeAthlete;
    }

    /**
     * 根据方案id 查询专家
     * @param schemeId 方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectAuExp")
    public AtsSchemeExpert selectAuExp(Integer schemeId){
        //调用咨询的查询专家selectByPrimaryKeyFive
        AtsSchemeExpert atsSchemeExpert=nutritionAtsSchemeExpertService.selectByPrimaryKeyFive(schemeId);
        //返回咨询表
        return atsSchemeExpert;
    }
}
